.TH std::bit_floor 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::bit_floor \- std::bit_floor

.SH Synopsis
   Defined in header <bit>
   template< class T >                     \fI(since C++20)\fP
   constexpr T bit_floor( T x ) noexcept;

   If x is not zero, calculates the largest integral power of two that is not greater
   than x. If x is zero, returns zero.

   This overload participates in overload resolution only if T is an unsigned integer
   type (that is, unsigned char, unsigned short, unsigned int, unsigned long, unsigned
   long long, or an extended unsigned integer type).

.SH Parameters

   x - unsigned integer value

.SH Return value

   Zero if x is zero; otherwise, the largest integral power of two that is not greater
   than x.

.SH Notes

   Feature-test macro  Value    Std              Feature
   __cpp_lib_int_pow2 202002L (C++20) Integral power-of-2 operations

.SH Possible implementation

   template<std::unsigned_integral T>
       requires !std::same_as<T, bool> && !std::same_as<T, char> &&
                !std::same_as<T, char8_t> && !std::same_as<T, char16_t> &&
                !std::same_as<T, char32_t> && !std::same_as<T, wchar_t>
   constexpr T bit_floor(T x) noexcept
   {
       if (x != 0)
           return T{1} << (std::bit_width(x) - 1);
       return 0;
   }

.SH Example


// Run this code

 #include <bit>
 #include <bitset>
 #include <iostream>

 int main()
 {
     using bin = std::bitset<8>;

     for (unsigned x = 0; x != 10; ++x)
     {
         auto const z = std::bit_floor(x); // `floor2` before P1956R1
         std::cout << "bit_floor( " << bin(x) << " ) = " << bin(z) << '\\n';
     }
 }

.SH Output:

 bit_floor( 00000000 ) = 00000000
 bit_floor( 00000001 ) = 00000001
 bit_floor( 00000010 ) = 00000010
 bit_floor( 00000011 ) = 00000010
 bit_floor( 00000100 ) = 00000100
 bit_floor( 00000101 ) = 00000100
 bit_floor( 00000110 ) = 00000100
 bit_floor( 00000111 ) = 00000100
 bit_floor( 00001000 ) = 00001000
 bit_floor( 00001001 ) = 00001000

.SH See also

   bit_ceil       finds the smallest integral power of two not less than the given
   (C++20)        value
                  \fI(function template)\fP
   rotr           computes the result of bitwise right-rotation
   (C++20)        \fI(function template)\fP
   bit_width      finds the smallest number of bits needed to represent the given value
   (C++20)        \fI(function template)\fP
   has_single_bit checks if a number is an integral power of 2
   (C++20)        \fI(function template)\fP
